import type { RouteRecordRaw } from 'vue-router'

/**
 * 将单个路由包装在 PageLayout 中
 * @param route 需要包装的路由配置
 * @returns 包装后的路由配置
 */
export function withLayout(route: RouteRecordRaw): RouteRecordRaw {
  // 确保路径以 / 开头
  const normalizePath = (path: string) => {
    return path.startsWith('/') ? path : `/${path}`
  }

  // 如果路由已经有 children，说明是父路由，直接添加 component 即可
  if (route.children && route.children.length > 0) {
    const layoutRoute: RouteRecordRaw = {
      path: normalizePath(route.path),
      name: route.name,
      component: () => import('@/features/constant/layout/PageLayout.vue'),
      redirect: route.redirect,
      meta: route.meta,
      children: route.children,
    }
    return layoutRoute
  }

  // 如果是叶子路由，需要包装一层
  return {
    path: normalizePath(route.path),
    component: () => import('@/features/constant/layout/PageLayout.vue'),
    redirect: route.redirect,
    meta: route.meta,
    children: [route],
  }
}

/**
 * 路由树节点
 */
interface RouteNode {
  path: string
  route?: RouteRecordRaw
  children: Map<string, RouteNode>
  filePath: string
  depth: number
}

/**
 * 从文件路径提取路由层级信息
 * @param filePath 文件路径，例如：/src/features/crud/product/trademark/trademark.route.ts
 * @returns 路径段数组，例如：['product', 'trademark'] 或 ['acl', 'user']
 */
function extractPathSegments(filePath: string): string[] {
  // 提取 features 目录后的路径部分（排除 constant 目录）
  // 匹配 /features/{module}/{...path}/xxx.route.ts，其中 module 不是 constant
  const match = filePath.match(/\/features\/(?!constant\/)([^/]+)\/(.+)\/[^/]+\.route\.ts$/)
  if (!match || !match[2]) {
    // 如果是顶层路由文件，如 /features/common/acl/acl.route.ts
    const topMatch = filePath.match(/\/features\/(?!constant\/)([^/]+)\/([^/]+\.route\.ts)$/)
    if (topMatch) return []
    return []
  }
  return match[2].split('/')
}

/**
 * 自动捕获 features 目录下的所有路由配置（排除 constant）
 * 使用 Vite 的 import.meta.glob 动态导入所有 *.route.ts 文件
 * 支持 common、crud 等所有非 constant 目录
 */
const featureRouteModules = import.meta.glob<{ default: RouteRecordRaw[] }>(
  '@/features/**/**.route.ts',
  { eager: true },
)

/**
 * 过滤掉 constant 目录下的路由
 */
const filteredRouteModules = Object.fromEntries(
  Object.entries(featureRouteModules).filter(([path]) => !path.includes('/constant/')),
)

/**
 * 构建路由树
 * 根据文件路径自动组装父子路由关系
 */
function buildRouteTree(): Map<string, RouteNode> {
  const rootNodes = new Map<string, RouteNode>()

  // 遍历所有路由模块
  Object.entries(filteredRouteModules).forEach(([filePath, module]) => {
    const routes = module.default || []
    const segments = extractPathSegments(filePath)

    routes.forEach((route) => {
      // 如果没有层级，直接作为根路由
      if (segments.length === 0) {
        const key = route.path.replace(/^\//, '') || 'root'
        rootNodes.set(key, {
          path: route.path,
          route,
          children: new Map(),
          filePath,
          depth: 0,
        })
        return
      }

      // 根据路径段构建树形结构
      let currentMap = rootNodes
      let currentNode: RouteNode | undefined

      segments.forEach((segment, index) => {
        if (!currentMap.has(segment)) {
          currentMap.set(segment, {
            path: `/${segments.slice(0, index + 1).join('/')}`,
            children: new Map(),
            filePath,
            depth: index,
          })
        }

        currentNode = currentMap.get(segment)!
        currentMap = currentNode.children
      })

      // 将路由配置附加到最深层节点
      if (currentNode) {
        currentNode.route = route
      }
    })
  })

  return rootNodes
}

/**
 * 将路由树节点转换为 Vue Router 配置
 * @param node 路由树节点
 * @returns Vue Router 路由配置
 */
function nodeToRoute(node: RouteNode): RouteRecordRaw | null {
  // 如果节点没有路由配置且没有子节点，返回 null
  if (!node.route && node.children.size === 0) {
    return null
  }

  // 收集所有子路由
  const children: RouteRecordRaw[] = []
  node.children.forEach((childNode) => {
    const childRoute = nodeToRoute(childNode)
    if (childRoute) {
      children.push(childRoute)
    }
  })

  // 如果有路由配置，使用它；否则创建一个包装路由
  if (node.route) {
    const route = { ...node.route }
    // 确保 path 以 / 开头
    if (route.path && !route.path.startsWith('/')) {
      route.path = `/${route.path}`
    }
    // 如果有子路由，合并进去
    if (children.length > 0) {
      route.children = [...(route.children || []), ...children]
    }
    return route
  }

  // 如果没有路由配置但有子节点，创建一个包装路由
  return {
    path: node.path,
    name: node.path.split('/').pop() || 'wrapper',
    children,
    meta: {
      title: node.path.split('/').pop() || 'Wrapper',
    },
  } as RouteRecordRaw
}

/**
 * 处理导入的路由模块，自动构建父子关系并使用 withLayout 包装
 */
function processFeatureRoutes(): RouteRecordRaw[] {
  const routeTree = buildRouteTree()
  const routes: RouteRecordRaw[] = []

  routeTree.forEach((node) => {
    const route = nodeToRoute(node)
    if (route) {
      // 只对顶层路由使用 withLayout 包装
      routes.push(withLayout(route))
    }
  })
  return routes
}

/**
 * 导出自动捕获并组装的 Feature 路由（common、crud 等）
 */
export const autoAsyncRoutes = processFeatureRoutes()

/**
 * 默认导出，方便直接使用
 */
export default autoAsyncRoutes
